package hyl.core.struct;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import hyl.core.MyFun;
import hyl.core.fun.MyIS;

public class MyCollect {
	// / <summary> 0925 阿有 只用于 tree类型 属性
	// / 例: 是否包含判断(c, d)
	// / 长值 01, 短值 01 包含关系成立
	// /
	// / 长值 01, 短值 01.01 包含关系成立
	// / 长值 01.01, 短值 01.01 包含关系成立
	// /
	// / 长值 01, 短值 01.01.01 包含关系成立
	// / 长值 01.01, 短值 01.01.01 包含关系成立
	// / 长值 01.01.01, 短值 01.01.01 包含关系成立
	// /
	// / 其它值不成立
	// / 长值 01.01, 短值 01 包含关系不成立
	// / </summary>
	public static boolean 包含(String 长值, String 短值) {
		if (长值 == null || 短值 == null) {
			return false;
		}
		长值 = "," + 长值 + ",";
		String str = "";
		String a = "";
		int i = 短值.indexOf('.', 0);
		while (i != -1) {
			a = 短值.substring(0, i);
			i++;
			i = 短值.indexOf('.', i);
			str = "," + a + ",";
			if (长值.contains(str)) {
				return true;
			}
		}
		if (i == -1) {
			str = "," + 短值 + ",";
			if (长值.contains(str)) {
				return true;
			}
		}
		return false;
	}

	// / <summary>
	// / 用于数组项的判断
	// / 如果数组中有该值则返回true
	// / </summary>
	public static boolean 包含(String[] array, Object 值) {
		if (array == null || 值 == null) {
			return false;
		}
		return Arrays.binarySearch(array, 值) != -1;
	}

	public static ArrayList<String> split(String str) {
		return split(str, ",");
	}

	public static ArrayList<String> split(String str, String sep) {
		if (MyFun.isEmpty(str)) {
			return null;
		}
		ArrayList<String> ls = new ArrayList<>();
		ls.addAll(Arrays.asList(str.split(sep)));
		return ls;
	}

	/**
	 * 组合
	 * 
	 * @param ss
	 * @return
	 */
	public static String weave(Object[] ss) {
		return weave(ss, ",");
	}

	public static String weave(Iterator<Object> ss) {
		return weave(ss, ",");
	}

	public static String weave(Object[] ss, String sep) {
		if (ss.length == 0) {
			return "";
		}
		StringBuilder s = new StringBuilder();
		int i = 0;
		for (; i < ss.length - 1; i++) {
			s.append(ss[i].toString());
			s.append(sep);
		}
		s.append(ss[i].toString());
		return s.toString();
	}

	public static String weave(Iterator<Object> ss, String sep) {
		if (!ss.hasNext()) {
			return "";
		}
		StringBuilder s = new StringBuilder();
		Object obj;
		obj = ss.next();
		while (ss.hasNext()) {
			obj = ss.next();
			s.append(sep).append(obj.toString());
		}
		return s.toString();
	}

	/**
	 * 
	 * @param headers 头部字段
	 * @param values  body 数据值
	 * @return
	 */
	@SuppressWarnings({ "rawtypes", "unchecked" })
	public static Map arr2Map(String[] headers, Object[] values) {
		if (null == headers || null == values) {
			return null;
		}
		if (headers.length != values.length)
			return null;
		Map mp = new HashMap();
		for (int i = 0; i < headers.length; i++) {
			mp.put(headers[i], values[i]);
		}
		return mp;
	}

	/**
	 * 浅层对比,不下钻对比
	 * 
	 * @param a1
	 * @param a2
	 * @return
	 */
	public static <T> boolean eq(T a1, T a2) {
		if (a1 == null && a2 == null)
			return true;
		else if (a1 == null && a2 != null)
			return false;
		else if (a1 != null && a2 == null)
			return false;
		else if (MyIS.isStr(a1)) {
			return MyFun.eqStr((String) a1, (String) a2);
		} else
			return ((T) a1).equals((T) a2);
	}

	/**
	 * 浅层,整体比较
	 * 
	 * @param b1
	 * @param b2
	 * @return
	 */
	public static boolean eqMap(Map<?, ?> b1, Map<?, ?> b2) {
		if (b1.isEmpty() && b2.isEmpty())
			return true;
		if (b1.size() != b2.size())
			return false;
		for (Object item : b1.keySet()) {
			if (b2.containsKey(item))
				if (!eq(b1.get(item), b2.get(item)))
					return false;
		}
		return true;
	}

	/**
	 * 浅层,部分比较
	 * 
	 * @param b1
	 * @param b2
	 * @return
	 */
	public static boolean eqMap(Map<?, ?> b1, Map<?, ?> b2, String[] 比较字段) {
		if (b1.isEmpty() && b2.isEmpty())
			return true;
		if (b1.size() != b2.size())
			return false;
		if (MyFun.isEmpty(比较字段))
			return eqMap(b1, b2);
		for (String key : 比较字段) {
			Object o1 = b1.get(key);
			Object o2 = b1.get(key);
			if (!eq(o1, o2))
				return false;
		}
		return true;
	}

	/**
	 * map 深度递归对比,下钻对比
	 * 
	 * @param a1
	 * @param a2
	 * @return
	 */
	@SuppressWarnings({ "unchecked", "rawtypes" })
	public static <T> boolean eq2(T a1, T a2) {
		if (!eq(a1, a2))
			return false;
		if (MyIS.isMap(a1) && MyIS.isMap(a2)) {
			Map<String, Object> b1 = (Map<String, Object>) a1;
			Map<String, Object> b2 = (Map<String, Object>) a2;
			if (b1.isEmpty() && b2.isEmpty())
				return true;
			if (b1.size() != b2.size())
				return false;
			for (Map.Entry<String, Object> item : b1.entrySet()) {
				if (b2.containsKey(item.getKey()))
					if (!eq2(item.getValue(), b2.get(item.getKey())))
						return false;
			}
			return true;
		} else if (MyIS.isArray(a1) && MyIS.isArray(a2)) {
			Object[] b1 = (Object[]) a1;
			Object[] b2 = (Object[]) a2;
			for (Object item1 : b1) {
				for (Object item2 : b2) {
					if (!eq2(item1, item2))
						return false;
				}
			}
			return true;
		} else if (MyIS.isList(a1) && MyIS.isList(a2)) {
			List b1 = (List) a1;
			List b2 = (List) a2;
			for (Object item1 : b1) {
				for (Object item2 : b2) {
					if (!eq2(item1, item2))
						return false;
				}
			}
			return true;
		} else {
			return a1.equals(a2);
		}
	}

	/**
	 * 用来比较 复合 key值 非常方便<br>
	 * 一般来说多个字段比较,性能比较低,可以考虑把多个字段的hash组合成一个byte[]<br>
	 * 然后一起比较可以提升性能
	 * 
	 * @param o1
	 * @param o2
	 * @return
	 */
	public static boolean eqArray(byte[] o1, byte[] o2) {
		if (MyFun.isEmpty(o1) || MyFun.isEmpty(o2))
			return false;
		if (o1.length != o2.length)
			return false;
		for (int i = 0; i < o1.length; i++) {
			if (o1[i] != o2[i])
				return false;
		}
		return true;
	}
}
